﻿using System;

namespace Polymorphism
{
    /*
     C# 多态性
     多态是同一个行为具有多个不同表现形式或形态的能力。
     多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。
     多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。
     在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。
     静态多态性
     在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为
        函数重载
        运算符重载
     */

    /*
     函数重载
     您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不同重载只有返回类型不同的函数声明。
     */
    public class TestData
    {
        public int Add(int a, int b, int c)
        {
            return a + b + c;
        }

        public int Add(int a, int b)
        {
            return a + b;
        }

        public static void Execute()
        {
            TestData dataClass = new TestData();
            int add1 = dataClass.Add(1, 2);
            int add2 = dataClass.Add(1, 2, 3);

            Console.WriteLine("add1 : " + add1);
            Console.WriteLine("add2 : " + add2);
        }
    }

    class Printdata
    {
        void print(int i)
        {
            Console.WriteLine("输出整型: {0}", i);
        }

        void print(double f)
        {
            Console.WriteLine("输出浮点型: {0}", f);
        }

        void print(string s)
        {
            Console.WriteLine("输出字符串: {0}", s);
        }

        public static void Execute()
        {
            Printdata p = new();
            p.print(1);
            p.print(1.23);
            p.print("Hello World!");
            Console.ReadKey();
        }
    }

    /*
     C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。
     抽象类包含抽象方法，抽象方法可被派生类实现。
     请注意，下面是有关抽象类的一些规则：
        您不能创建一个抽象类的实例。
        您不能在一个抽象类外部声明一个抽象方法。
        通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。
     */
    abstract class Shape1
    {
        abstract public int area();
    }

    class Rectangle1 : Shape1
    {
        private int length;
        private int width;

        public Rectangle1(int a = 0, int b = 0)
        {
            length = a;
            width = b;
        }

        public override int area()
        {
            Console.WriteLine("Rectangle 类的面积: ");
            return (width * length);
        }

        public static void Execute()
        {
            Rectangle1 r = new Rectangle1(10, 7);
            double a = r.area();
            Console.WriteLine("面积: {0}", a);
            Console.ReadKey();
        }
    }

    /*
     当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。
     虚方法是使用关键字 virtual 声明的。
     虚方法可以在不同的继承类中有不同的实现。
     对虚方法的调用是在运行时发生的。
     动态多态性是通过 抽象类 和 虚方法 实现的。
     */
    public class Shape2
    {
        public int X { get; private set; }
        public int Y { get; private set; }
        public int Height { get; set; }
        public int Width { get; set; }

        public virtual void Draw()
        {
            Console.WriteLine("执行基类的画图任务");
        }
    }

    class Circle2 : Shape2
    {
        public override void Draw()
        {
            Console.WriteLine("画一个圆形");
            base.Draw();
        }
    }

    class Rectangle2 : Shape2
    {
        public override void Draw()
        {
            Console.WriteLine("画一个长方形");
            base.Draw();
        }
    }

    class Triangle2 : Shape2
    {
        public override void Draw()
        {
            Console.WriteLine("画一个三角形");
            base.Draw();
        }
    }

    class Shape3
    {
        protected int width, height;

        public Shape3(int a = 0, int b = 0)
        {
            width = a;
            height = b;
        }

        public virtual int area()
        {
            Console.WriteLine("父类的面积: ");
            return 0;
        }
    }

    class Rectangle3 : Shape3
    {
        public Rectangle3(int a = 0, int b = 0):base(a, b)
        { }

        public override int area()
        {
            Console.WriteLine("Rectangle 类的面积: ");
            return (width * height);
        }
    }

    class Triangle3 : Shape3
    {
        public Triangle3(int a = 0, int b = 0): base(a, b)
        { }

        public override int area()
        {
            Console.WriteLine("Triangle 类的面积: ");
            return (width * height / 2);
        }
    }

    class Caller
    {
        public void CallArea(Shape3 sh)
        {
            int a;
            a = sh.area();
            Console.WriteLine("面积: {0}", a);
        }
    }
}